home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / gtk-2.0 / gtk / gtkwidget.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-25  |  31.2 KB  |  793 lines
  1. /* GTK - The GIMP Toolkit
  2.  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
  3.  *
  4.  * This library is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Lesser General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2 of the License, or (at your option) any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
  12.  * Lesser General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Lesser General Public
  15.  * License along with this library; if not, write to the
  16.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17.  * Boston, MA 02111-1307, USA.
  18.  */
  19.  
  20. /*
  21.  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22.  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23.  * files for a list of changes.  These files are distributed with
  24.  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  25.  */
  26.  
  27. #ifndef __GTK_WIDGET_H__
  28. #define __GTK_WIDGET_H__
  29.  
  30. #include <gdk/gdk.h>
  31. #include <gtk/gtkaccelgroup.h>
  32. #include <gtk/gtkobject.h>
  33. #include <gtk/gtkadjustment.h>
  34. #include <gtk/gtkstyle.h>
  35. #include <gtk/gtksettings.h>
  36. #include <atk/atkobject.h>
  37.  
  38. G_BEGIN_DECLS
  39.  
  40. /* The flags that are used by GtkWidget on top of the
  41.  * flags field of GtkObject.
  42.  */
  43. typedef enum
  44. {
  45.   GTK_TOPLEVEL         = 1 << 4,
  46.   GTK_NO_WINDOW        = 1 << 5,
  47.   GTK_REALIZED         = 1 << 6,
  48.   GTK_MAPPED           = 1 << 7,
  49.   GTK_VISIBLE          = 1 << 8,
  50.   GTK_SENSITIVE        = 1 << 9,
  51.   GTK_PARENT_SENSITIVE = 1 << 10,
  52.   GTK_CAN_FOCUS        = 1 << 11,
  53.   GTK_HAS_FOCUS        = 1 << 12,
  54.  
  55.   /* widget is allowed to receive the default via gtk_widget_grab_default
  56.    * and will reserve space to draw the default if possible
  57.    */
  58.   GTK_CAN_DEFAULT      = 1 << 13,
  59.  
  60.   /* the widget currently is receiving the default action and should be drawn
  61.    * appropriately if possible
  62.    */
  63.   GTK_HAS_DEFAULT      = 1 << 14,
  64.  
  65.   GTK_HAS_GRAB           = 1 << 15,
  66.   GTK_RC_STYLE           = 1 << 16,
  67.   GTK_COMPOSITE_CHILD  = 1 << 17,
  68.   GTK_NO_REPARENT      = 1 << 18,
  69.   GTK_APP_PAINTABLE    = 1 << 19,
  70.  
  71.   /* the widget when focused will receive the default action and have
  72.    * HAS_DEFAULT set even if there is a different widget set as default
  73.    */
  74.   GTK_RECEIVES_DEFAULT = 1 << 20,
  75.  
  76.   GTK_DOUBLE_BUFFERED  = 1 << 21,
  77.   GTK_NO_SHOW_ALL      = 1 << 22
  78. } GtkWidgetFlags;
  79.  
  80. /* Kinds of widget-specific help */
  81. typedef enum
  82. {
  83.   GTK_WIDGET_HELP_TOOLTIP,
  84.   GTK_WIDGET_HELP_WHATS_THIS
  85. } GtkWidgetHelpType;
  86.  
  87. /* Macro for casting a pointer to a GtkWidget or GtkWidgetClass pointer.
  88.  * Macros for testing whether `widget' or `klass' are of type GTK_TYPE_WIDGET.
  89.  */
  90. #define GTK_TYPE_WIDGET              (gtk_widget_get_type ())
  91. #define GTK_WIDGET(widget)          (G_TYPE_CHECK_INSTANCE_CAST ((widget), GTK_TYPE_WIDGET, GtkWidget))
  92. #define GTK_WIDGET_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET, GtkWidgetClass))
  93. #define GTK_IS_WIDGET(widget)          (G_TYPE_CHECK_INSTANCE_TYPE ((widget), GTK_TYPE_WIDGET))
  94. #define GTK_IS_WIDGET_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET))
  95. #define GTK_WIDGET_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WIDGET, GtkWidgetClass))
  96.  
  97. /* Macros for extracting various fields from GtkWidget and GtkWidgetClass.
  98.  */
  99. #define GTK_WIDGET_TYPE(wid)          (GTK_OBJECT_TYPE (wid))
  100. #define GTK_WIDGET_STATE(wid)          (GTK_WIDGET (wid)->state)
  101. #define GTK_WIDGET_SAVED_STATE(wid)      (GTK_WIDGET (wid)->saved_state)
  102.  
  103. /* Macros for extracting the widget flags from GtkWidget.
  104.  */
  105. #define GTK_WIDGET_FLAGS(wid)          (GTK_OBJECT_FLAGS (wid))
  106. #define GTK_WIDGET_TOPLEVEL(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_TOPLEVEL) != 0)
  107. #define GTK_WIDGET_NO_WINDOW(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_NO_WINDOW) != 0)
  108. #define GTK_WIDGET_REALIZED(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_REALIZED) != 0)
  109. #define GTK_WIDGET_MAPPED(wid)          ((GTK_WIDGET_FLAGS (wid) & GTK_MAPPED) != 0)
  110. #define GTK_WIDGET_VISIBLE(wid)          ((GTK_WIDGET_FLAGS (wid) & GTK_VISIBLE) != 0)
  111. #define GTK_WIDGET_DRAWABLE(wid)      (GTK_WIDGET_VISIBLE (wid) && GTK_WIDGET_MAPPED (wid))
  112. #define GTK_WIDGET_SENSITIVE(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_SENSITIVE) != 0)
  113. #define GTK_WIDGET_PARENT_SENSITIVE(wid)  ((GTK_WIDGET_FLAGS (wid) & GTK_PARENT_SENSITIVE) != 0)
  114. #define GTK_WIDGET_IS_SENSITIVE(wid)      (GTK_WIDGET_SENSITIVE (wid) && \
  115.                        GTK_WIDGET_PARENT_SENSITIVE (wid))
  116. #define GTK_WIDGET_CAN_FOCUS(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_FOCUS) != 0)
  117. #define GTK_WIDGET_HAS_FOCUS(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_FOCUS) != 0)
  118. #define GTK_WIDGET_CAN_DEFAULT(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_DEFAULT) != 0)
  119. #define GTK_WIDGET_HAS_DEFAULT(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_DEFAULT) != 0)
  120. #define GTK_WIDGET_HAS_GRAB(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_GRAB) != 0)
  121. #define GTK_WIDGET_RC_STYLE(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_RC_STYLE) != 0)
  122. #define GTK_WIDGET_COMPOSITE_CHILD(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_COMPOSITE_CHILD) != 0)
  123. #define GTK_WIDGET_APP_PAINTABLE(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_APP_PAINTABLE) != 0)
  124. #define GTK_WIDGET_RECEIVES_DEFAULT(wid)  ((GTK_WIDGET_FLAGS (wid) & GTK_RECEIVES_DEFAULT) != 0)
  125. #define GTK_WIDGET_DOUBLE_BUFFERED(wid)      ((GTK_WIDGET_FLAGS (wid) & GTK_DOUBLE_BUFFERED) != 0)
  126.   
  127. /* Macros for setting and clearing widget flags.
  128.  */
  129. #define GTK_WIDGET_SET_FLAGS(wid,flag)      G_STMT_START{ (GTK_WIDGET_FLAGS (wid) |= (flag)); }G_STMT_END
  130. #define GTK_WIDGET_UNSET_FLAGS(wid,flag)  G_STMT_START{ (GTK_WIDGET_FLAGS (wid) &= ~(flag)); }G_STMT_END
  131.  
  132. #define GTK_TYPE_REQUISITION              (gtk_requisition_get_type ())
  133.  
  134. /* forward declaration to avoid excessive includes (and concurrent includes)
  135.  */
  136. typedef struct _GtkRequisition       GtkRequisition;
  137. typedef     GdkRectangle       GtkAllocation;
  138. typedef struct _GtkSelectionData   GtkSelectionData;
  139. typedef struct _GtkWidgetClass       GtkWidgetClass;
  140. typedef struct _GtkWidgetAuxInfo   GtkWidgetAuxInfo;
  141. typedef struct _GtkWidgetShapeInfo GtkWidgetShapeInfo;
  142. typedef struct _GtkClipboard       GtkClipboard;
  143. typedef void     (*GtkCallback)        (GtkWidget        *widget,
  144.                     gpointer      data);
  145.  
  146. /* A requisition is a desired amount of space which a
  147.  *  widget may request.
  148.  */
  149. struct _GtkRequisition
  150. {
  151.   gint width;
  152.   gint height;
  153. };
  154.  
  155. /* The widget is the base of the tree for displayable objects.
  156.  *  (A displayable object is one which takes up some amount
  157.  *  of screen real estate). It provides a common base and interface
  158.  *  which actual widgets must adhere to.
  159.  */
  160. struct _GtkWidget
  161. {
  162.   /* The object structure needs to be the first
  163.    *  element in the widget structure in order for
  164.    *  the object mechanism to work correctly. This
  165.    *  allows a GtkWidget pointer to be cast to a
  166.    *  GtkObject pointer.
  167.    */
  168.   GtkObject object;
  169.   
  170.   /* 16 bits of internally used private flags.
  171.    * this will be packed into the same 4 byte alignment frame that
  172.    * state and saved_state go. we therefore don't waste any new
  173.    * space on this.
  174.    */
  175.   guint16 private_flags;
  176.   
  177.   /* The state of the widget. There are actually only
  178.    *  5 widget states (defined in "gtkenums.h").
  179.    */
  180.   guint8 state;
  181.   
  182.   /* The saved state of the widget. When a widget's state
  183.    *  is changed to GTK_STATE_INSENSITIVE via
  184.    *  "gtk_widget_set_state" or "gtk_widget_set_sensitive"
  185.    *  the old state is kept around in this field. The state
  186.    *  will be restored once the widget gets sensitive again.
  187.    */
  188.   guint8 saved_state;
  189.   
  190.   /* The widget's name. If the widget does not have a name
  191.    *  (the name is NULL), then its name (as returned by
  192.    *  "gtk_widget_get_name") is its class's name.
  193.    * Among other things, the widget name is used to determine
  194.    *  the style to use for a widget.
  195.    */
  196.   gchar *name;
  197.   
  198.   /*< public >*/
  199.  
  200.   /* The style for the widget. The style contains the
  201.    *  colors the widget should be drawn in for each state
  202.    *  along with graphics contexts used to draw with and
  203.    *  the font to use for text.
  204.    */
  205.   GtkStyle *style;
  206.   
  207.   /* The widget's desired size.
  208.    */
  209.   GtkRequisition requisition;
  210.   
  211.   /* The widget's allocated size.
  212.    */
  213.   GtkAllocation allocation;
  214.   
  215.   /* The widget's window or its parent window if it does
  216.    *  not have a window. (Which will be indicated by the
  217.    *  GTK_NO_WINDOW flag being set).
  218.    */
  219.   GdkWindow *window;
  220.   
  221.   /* The widget's parent.
  222.    */
  223.   GtkWidget *parent;
  224. };
  225.  
  226. struct _GtkWidgetClass
  227. {
  228.   /* The object class structure needs to be the first
  229.    *  element in the widget class structure in order for
  230.    *  the class mechanism to work correctly. This allows a
  231.    *  GtkWidgetClass pointer to be cast to a GtkObjectClass
  232.    *  pointer.
  233.    */
  234.   GtkObjectClass parent_class;
  235.  
  236.   /*< public >*/
  237.   
  238.   guint activate_signal;
  239.  
  240.   guint set_scroll_adjustments_signal;
  241.  
  242.   /*< private >*/
  243.   
  244.   /* seldomly overidden */
  245.   void (*dispatch_child_properties_changed) (GtkWidget   *widget,
  246.                          guint        n_pspecs,
  247.                          GParamSpec **pspecs);
  248.  
  249.   /* basics */
  250.   void (* show)               (GtkWidget        *widget);
  251.   void (* show_all)            (GtkWidget        *widget);
  252.   void (* hide)               (GtkWidget        *widget);
  253.   void (* hide_all)            (GtkWidget        *widget);
  254.   void (* map)               (GtkWidget        *widget);
  255.   void (* unmap)           (GtkWidget        *widget);
  256.   void (* realize)           (GtkWidget        *widget);
  257.   void (* unrealize)           (GtkWidget        *widget);
  258.   void (* size_request)           (GtkWidget        *widget,
  259.                 GtkRequisition   *requisition);
  260.   void (* size_allocate)       (GtkWidget        *widget,
  261.                 GtkAllocation    *allocation);
  262.   void (* state_changed)       (GtkWidget        *widget,
  263.                 GtkStateType         previous_state);
  264.   void (* parent_set)           (GtkWidget        *widget,
  265.                 GtkWidget        *previous_parent);
  266.   void (* hierarchy_changed)   (GtkWidget        *widget,
  267.                 GtkWidget        *previous_toplevel);
  268.   void (* style_set)           (GtkWidget        *widget,
  269.                 GtkStyle         *previous_style);
  270.   void (* direction_changed)   (GtkWidget        *widget,
  271.                 GtkTextDirection  previous_direction);
  272.   void (* grab_notify)         (GtkWidget        *widget,
  273.                 gboolean          was_grabbed);
  274.   void (* child_notify)        (GtkWidget     *widget,
  275.                 GParamSpec       *pspec);
  276.   
  277.   /* Mnemonics */
  278.   gboolean (* mnemonic_activate) (GtkWidget    *widget,
  279.                   gboolean      group_cycling);
  280.   
  281.   /* explicit focus */
  282.   void     (* grab_focus)      (GtkWidget        *widget);
  283.   gboolean (* focus)           (GtkWidget        *widget,
  284.                                 GtkDirectionType  direction);
  285.   
  286.   /* events */
  287.   gboolean (* event)            (GtkWidget         *widget,
  288.                      GdkEvent         *event);
  289.   gboolean (* button_press_event)    (GtkWidget         *widget,
  290.                      GdkEventButton      *event);
  291.   gboolean (* button_release_event)    (GtkWidget         *widget,
  292.                      GdkEventButton      *event);
  293.   gboolean (* scroll_event)        (GtkWidget           *widget,
  294.                      GdkEventScroll      *event);
  295.   gboolean (* motion_notify_event)    (GtkWidget         *widget,
  296.                      GdkEventMotion      *event);
  297.   gboolean (* delete_event)        (GtkWidget         *widget,
  298.                      GdkEventAny         *event);
  299.   gboolean (* destroy_event)        (GtkWidget         *widget,
  300.                      GdkEventAny         *event);
  301.   gboolean (* expose_event)        (GtkWidget         *widget,
  302.                      GdkEventExpose      *event);
  303.   gboolean (* key_press_event)        (GtkWidget         *widget,
  304.                      GdkEventKey         *event);
  305.   gboolean (* key_release_event)    (GtkWidget         *widget,
  306.                      GdkEventKey         *event);
  307.   gboolean (* enter_notify_event)    (GtkWidget         *widget,
  308.                      GdkEventCrossing    *event);
  309.   gboolean (* leave_notify_event)    (GtkWidget         *widget,
  310.                      GdkEventCrossing    *event);
  311.   gboolean (* configure_event)        (GtkWidget         *widget,
  312.                      GdkEventConfigure   *event);
  313.   gboolean (* focus_in_event)        (GtkWidget         *widget,
  314.                      GdkEventFocus       *event);
  315.   gboolean (* focus_out_event)        (GtkWidget         *widget,
  316.                      GdkEventFocus       *event);
  317.   gboolean (* map_event)        (GtkWidget         *widget,
  318.                      GdkEventAny         *event);
  319.   gboolean (* unmap_event)        (GtkWidget         *widget,
  320.                      GdkEventAny         *event);
  321.   gboolean (* property_notify_event)    (GtkWidget         *widget,
  322.                      GdkEventProperty    *event);
  323.   gboolean (* selection_clear_event)    (GtkWidget         *widget,
  324.                      GdkEventSelection   *event);
  325.   gboolean (* selection_request_event)    (GtkWidget         *widget,
  326.                      GdkEventSelection   *event);
  327.   gboolean (* selection_notify_event)    (GtkWidget         *widget,
  328.                      GdkEventSelection   *event);
  329.   gboolean (* proximity_in_event)    (GtkWidget         *widget,
  330.                      GdkEventProximity   *event);
  331.   gboolean (* proximity_out_event)    (GtkWidget         *widget,
  332.                      GdkEventProximity   *event);
  333.   gboolean (* visibility_notify_event)    (GtkWidget         *widget,
  334.                      GdkEventVisibility  *event);
  335.   gboolean (* client_event)        (GtkWidget         *widget,
  336.                      GdkEventClient         *event);
  337.   gboolean (* no_expose_event)        (GtkWidget         *widget,
  338.                      GdkEventAny         *event);
  339.   gboolean (* window_state_event)    (GtkWidget         *widget,
  340.                      GdkEventWindowState *event);
  341.   
  342.   /* selection */
  343.   void (* selection_get)           (GtkWidget          *widget,
  344.                     GtkSelectionData   *selection_data,
  345.                     guint               info,
  346.                     guint               time_);
  347.   void (* selection_received)      (GtkWidget          *widget,
  348.                     GtkSelectionData   *selection_data,
  349.                     guint               time_);
  350.  
  351.   /* Source side drag signals */
  352.   void (* drag_begin)               (GtkWidget           *widget,
  353.                     GdkDragContext     *context);
  354.   void (* drag_end)               (GtkWidget           *widget,
  355.                     GdkDragContext     *context);
  356.   void (* drag_data_get)           (GtkWidget          *widget,
  357.                     GdkDragContext     *context,
  358.                     GtkSelectionData   *selection_data,
  359.                     guint               info,
  360.                     guint               time_);
  361.   void (* drag_data_delete)        (GtkWidget           *widget,
  362.                     GdkDragContext     *context);
  363.  
  364.   /* Target side drag signals */
  365.   void (* drag_leave)               (GtkWidget           *widget,
  366.                     GdkDragContext     *context,
  367.                     guint               time_);
  368.   gboolean (* drag_motion)         (GtkWidget           *widget,
  369.                     GdkDragContext     *context,
  370.                     gint                x,
  371.                     gint                y,
  372.                     guint               time_);
  373.   gboolean (* drag_drop)           (GtkWidget           *widget,
  374.                     GdkDragContext     *context,
  375.                     gint                x,
  376.                     gint                y,
  377.                     guint               time_);
  378.   void (* drag_data_received)      (GtkWidget          *widget,
  379.                     GdkDragContext     *context,
  380.                     gint                x,
  381.                     gint                y,
  382.                     GtkSelectionData   *selection_data,
  383.                     guint               info,
  384.                     guint               time_);
  385.  
  386.   /* Signals used only for keybindings */
  387.   gboolean (* popup_menu)          (GtkWidget          *widget);
  388.  
  389.   /* If a widget has multiple tooltips/whatsthis, it should show the
  390.    * one for the current focus location, or if that doesn't make
  391.    * sense, should cycle through them showing each tip alongside
  392.    * whatever piece of the widget it applies to.
  393.    */
  394.   gboolean (* show_help)           (GtkWidget          *widget,
  395.                                     GtkWidgetHelpType   help_type);
  396.   
  397.   /* accessibility support 
  398.    */
  399.   AtkObject*   (*get_accessible)     (GtkWidget *widget);
  400.  
  401.   void         (*screen_changed)     (GtkWidget *widget,
  402.                                       GdkScreen *previous_screen);
  403.   gboolean     (*can_activate_accel) (GtkWidget *widget,
  404.                                       guint      signal_id);
  405.  
  406.   /* Sent when a grab is broken. */
  407.   gboolean (*grab_broken_event) (GtkWidget         *widget,
  408.                                  GdkEventGrabBroken  *event);
  409.  
  410.   /* Padding for future expansion */
  411.   void (*_gtk_reserved3) (void);
  412.   void (*_gtk_reserved4) (void);
  413.   void (*_gtk_reserved5) (void);
  414.   void (*_gtk_reserved6) (void);
  415.   void (*_gtk_reserved7) (void);
  416. };
  417.  
  418. struct _GtkWidgetAuxInfo
  419. {
  420.   gint x;
  421.   gint y;
  422.   gint width;
  423.   gint height;
  424.   guint x_set : 1;
  425.   guint y_set : 1;
  426. };
  427.  
  428. struct _GtkWidgetShapeInfo
  429. {
  430.   gint16     offset_x;
  431.   gint16     offset_y;
  432.   GdkBitmap *shape_mask;
  433. };
  434.  
  435. GType       gtk_widget_get_type          (void) G_GNUC_CONST;
  436. GtkWidget* gtk_widget_new          (GType        type,
  437.                        const gchar           *first_property_name,
  438.                        ...);
  439. GtkWidget* gtk_widget_ref          (GtkWidget           *widget);
  440. void       gtk_widget_unref          (GtkWidget           *widget);
  441. void       gtk_widget_destroy          (GtkWidget           *widget);
  442. void       gtk_widget_destroyed          (GtkWidget           *widget,
  443.                        GtkWidget          **widget_pointer);
  444. #ifndef GTK_DISABLE_DEPRECATED
  445. void       gtk_widget_set          (GtkWidget           *widget,
  446.                        const gchar         *first_property_name,
  447.                        ...) G_GNUC_NULL_TERMINATED;
  448. #endif /* GTK_DISABLE_DEPRECATED */
  449. void       gtk_widget_unparent          (GtkWidget           *widget);
  450. void       gtk_widget_show          (GtkWidget           *widget);
  451. void       gtk_widget_show_now            (GtkWidget           *widget);
  452. void       gtk_widget_hide          (GtkWidget           *widget);
  453. void       gtk_widget_show_all          (GtkWidget           *widget);
  454. void       gtk_widget_hide_all          (GtkWidget           *widget);
  455. void       gtk_widget_set_no_show_all     (GtkWidget           *widget,
  456.                        gboolean             no_show_all);
  457. gboolean   gtk_widget_get_no_show_all     (GtkWidget           *widget);
  458. void       gtk_widget_map          (GtkWidget           *widget);
  459. void       gtk_widget_unmap          (GtkWidget           *widget);
  460. void       gtk_widget_realize          (GtkWidget           *widget);
  461. void       gtk_widget_unrealize          (GtkWidget           *widget);
  462.  
  463. /* Queuing draws */
  464. void       gtk_widget_queue_draw      (GtkWidget           *widget);
  465. void       gtk_widget_queue_draw_area      (GtkWidget           *widget,
  466.                        gint                 x,
  467.                        gint                 y,
  468.                        gint                 width,
  469.                        gint                 height);
  470. #ifndef GTK_DISABLE_DEPRECATED
  471. void       gtk_widget_queue_clear      (GtkWidget           *widget);
  472. void       gtk_widget_queue_clear_area      (GtkWidget           *widget,
  473.                        gint                 x,
  474.                        gint                 y,
  475.                        gint                 width,
  476.                        gint                 height);
  477. #endif /* GTK_DISABLE_DEPRECATED */
  478.  
  479.  
  480. void       gtk_widget_queue_resize      (GtkWidget           *widget);
  481. void       gtk_widget_queue_resize_no_redraw (GtkWidget *widget);
  482. #ifndef GTK_DISABLE_DEPRECATED
  483. void       gtk_widget_draw          (GtkWidget           *widget,
  484.                        GdkRectangle           *area);
  485. #endif /* GTK_DISABLE_DEPRECATED */
  486. void       gtk_widget_size_request      (GtkWidget           *widget,
  487.                        GtkRequisition      *requisition);
  488. void       gtk_widget_size_allocate      (GtkWidget           *widget,
  489.                        GtkAllocation       *allocation);
  490. void       gtk_widget_get_child_requisition (GtkWidget           *widget,
  491.                          GtkRequisition    *requisition);
  492. void       gtk_widget_add_accelerator      (GtkWidget           *widget,
  493.                        const gchar         *accel_signal,
  494.                        GtkAccelGroup       *accel_group,
  495.                        guint                accel_key,
  496.                        GdkModifierType      accel_mods,
  497.                        GtkAccelFlags        accel_flags);
  498. gboolean   gtk_widget_remove_accelerator  (GtkWidget           *widget,
  499.                        GtkAccelGroup       *accel_group,
  500.                        guint                accel_key,
  501.                        GdkModifierType      accel_mods);
  502. void       gtk_widget_set_accel_path      (GtkWidget           *widget,
  503.                        const gchar         *accel_path,
  504.                        GtkAccelGroup       *accel_group);
  505. const gchar* _gtk_widget_get_accel_path   (GtkWidget           *widget,
  506.                        gboolean           *locked);
  507. GList*     gtk_widget_list_accel_closures (GtkWidget           *widget);
  508. gboolean   gtk_widget_can_activate_accel  (GtkWidget           *widget,
  509.                                            guint                signal_id);
  510. gboolean   gtk_widget_mnemonic_activate   (GtkWidget           *widget,
  511.                        gboolean             group_cycling);
  512. gboolean   gtk_widget_event          (GtkWidget           *widget,
  513.                        GdkEvent           *event);
  514. gint       gtk_widget_send_expose         (GtkWidget           *widget,
  515.                        GdkEvent            *event);
  516.  
  517. gboolean   gtk_widget_activate             (GtkWidget           *widget);
  518. gboolean   gtk_widget_set_scroll_adjustments (GtkWidget        *widget,
  519.                           GtkAdjustment    *hadjustment,
  520.                           GtkAdjustment    *vadjustment);
  521.      
  522. void       gtk_widget_reparent          (GtkWidget           *widget,
  523.                        GtkWidget           *new_parent);
  524. gboolean   gtk_widget_intersect          (GtkWidget           *widget,
  525.                        GdkRectangle           *area,
  526.                        GdkRectangle           *intersection);
  527. GdkRegion *gtk_widget_region_intersect      (GtkWidget           *widget,
  528.                        GdkRegion           *region);
  529.  
  530. void    gtk_widget_freeze_child_notify      (GtkWidget           *widget);
  531. void    gtk_widget_child_notify          (GtkWidget           *widget,
  532.                        const gchar           *child_property);
  533. void    gtk_widget_thaw_child_notify      (GtkWidget           *widget);
  534.  
  535. gboolean   gtk_widget_is_focus            (GtkWidget           *widget);
  536. void       gtk_widget_grab_focus      (GtkWidget           *widget);
  537. void       gtk_widget_grab_default      (GtkWidget           *widget);
  538.  
  539. void                  gtk_widget_set_name               (GtkWidget    *widget,
  540.                              const gchar  *name);
  541. G_CONST_RETURN gchar* gtk_widget_get_name               (GtkWidget    *widget);
  542. void                  gtk_widget_set_state              (GtkWidget    *widget,
  543.                              GtkStateType  state);
  544. void                  gtk_widget_set_sensitive          (GtkWidget    *widget,
  545.                              gboolean      sensitive);
  546. void                  gtk_widget_set_app_paintable      (GtkWidget    *widget,
  547.                              gboolean      app_paintable);
  548. void                  gtk_widget_set_double_buffered    (GtkWidget    *widget,
  549.                              gboolean      double_buffered);
  550. void                  gtk_widget_set_redraw_on_allocate (GtkWidget    *widget,
  551.                              gboolean      redraw_on_allocate);
  552. void                  gtk_widget_set_parent             (GtkWidget    *widget,
  553.                              GtkWidget    *parent);
  554. void                  gtk_widget_set_parent_window      (GtkWidget    *widget,
  555.                              GdkWindow    *parent_window);
  556. void                  gtk_widget_set_child_visible      (GtkWidget    *widget,
  557.                              gboolean      is_visible);
  558. gboolean              gtk_widget_get_child_visible      (GtkWidget    *widget);
  559.  
  560. GtkWidget *gtk_widget_get_parent          (GtkWidget           *widget);
  561. GdkWindow *gtk_widget_get_parent_window      (GtkWidget           *widget);
  562.  
  563. gboolean   gtk_widget_child_focus         (GtkWidget           *widget,
  564.                                            GtkDirectionType     direction);
  565.  
  566. void       gtk_widget_set_size_request    (GtkWidget           *widget,
  567.                                            gint                 width,
  568.                                            gint                 height);
  569. void       gtk_widget_get_size_request    (GtkWidget           *widget,
  570.                                            gint                *width,
  571.                                            gint                *height);
  572. #ifndef GTK_DISABLE_DEPRECATED
  573. void       gtk_widget_set_uposition      (GtkWidget           *widget,
  574.                        gint            x,
  575.                        gint            y);
  576. void       gtk_widget_set_usize          (GtkWidget           *widget,
  577.                        gint            width,
  578.                        gint            height);
  579. #endif
  580.  
  581. void       gtk_widget_set_events      (GtkWidget           *widget,
  582.                        gint            events);
  583. void       gtk_widget_add_events          (GtkWidget           *widget,
  584.                        gint                    events);
  585. void       gtk_widget_set_extension_events (GtkWidget        *widget,
  586.                         GdkExtensionMode    mode);
  587.  
  588. GdkExtensionMode gtk_widget_get_extension_events (GtkWidget    *widget);
  589. GtkWidget*   gtk_widget_get_toplevel    (GtkWidget    *widget);
  590. GtkWidget*   gtk_widget_get_ancestor    (GtkWidget    *widget,
  591.                      GType         widget_type);
  592. GdkColormap* gtk_widget_get_colormap    (GtkWidget    *widget);
  593. GdkVisual*   gtk_widget_get_visual    (GtkWidget    *widget);
  594.  
  595. GdkScreen *   gtk_widget_get_screen      (GtkWidget *widget);
  596. gboolean      gtk_widget_has_screen      (GtkWidget *widget);
  597. GdkDisplay *  gtk_widget_get_display     (GtkWidget *widget);
  598. GdkWindow *   gtk_widget_get_root_window (GtkWidget *widget);
  599. GtkSettings*  gtk_widget_get_settings    (GtkWidget *widget);
  600. GtkClipboard *gtk_widget_get_clipboard   (GtkWidget *widget,
  601.                       GdkAtom    selection);
  602.  
  603. #ifndef GTK_DISABLE_DEPRECATED
  604. #define gtk_widget_set_visual(widget,visual)  ((void) 0)
  605. #define gtk_widget_push_visual(visual)        ((void) 0)
  606. #define gtk_widget_pop_visual()               ((void) 0)
  607. #define gtk_widget_set_default_visual(visual) ((void) 0)
  608. #endif /* GTK_DISABLE_DEPRECATED */
  609.  
  610. /* Accessibility support */
  611. AtkObject*       gtk_widget_get_accessible               (GtkWidget          *widget);
  612.  
  613. /* The following functions must not be called on an already
  614.  * realized widget. Because it is possible that somebody
  615.  * can call get_colormap() or get_visual() and save the
  616.  * result, these functions are probably only safe to
  617.  * call in a widget's init() function.
  618.  */
  619. void         gtk_widget_set_colormap    (GtkWidget      *widget,
  620.                      GdkColormap    *colormap);
  621.  
  622. gint         gtk_widget_get_events    (GtkWidget    *widget);
  623. void         gtk_widget_get_pointer    (GtkWidget    *widget,
  624.                      gint        *x,
  625.                      gint        *y);
  626.  
  627. gboolean     gtk_widget_is_ancestor    (GtkWidget    *widget,
  628.                      GtkWidget    *ancestor);
  629.  
  630. gboolean     gtk_widget_translate_coordinates (GtkWidget  *src_widget,
  631.                            GtkWidget  *dest_widget,
  632.                            gint        src_x,
  633.                            gint        src_y,
  634.                            gint       *dest_x,
  635.                            gint       *dest_y);
  636.  
  637. /* Hide widget and return TRUE.
  638.  */
  639. gboolean     gtk_widget_hide_on_delete    (GtkWidget    *widget);
  640.  
  641. /* Widget styles.
  642.  */
  643. void       gtk_widget_set_style        (GtkWidget    *widget,
  644.                      GtkStyle    *style);
  645. void       gtk_widget_ensure_style    (GtkWidget    *widget);
  646. GtkStyle*  gtk_widget_get_style        (GtkWidget    *widget);
  647.  
  648. void        gtk_widget_modify_style       (GtkWidget            *widget,
  649.                        GtkRcStyle           *style);
  650. GtkRcStyle *gtk_widget_get_modifier_style (GtkWidget            *widget);
  651. void        gtk_widget_modify_fg          (GtkWidget            *widget,
  652.                        GtkStateType          state,
  653.                        const GdkColor       *color);
  654. void        gtk_widget_modify_bg          (GtkWidget            *widget,
  655.                        GtkStateType          state,
  656.                        const GdkColor       *color);
  657. void        gtk_widget_modify_text        (GtkWidget            *widget,
  658.                        GtkStateType          state,
  659.                        const GdkColor       *color);
  660. void        gtk_widget_modify_base        (GtkWidget            *widget,
  661.                        GtkStateType          state,
  662.                        const GdkColor       *color);
  663. void        gtk_widget_modify_font        (GtkWidget            *widget,
  664.                        PangoFontDescription *font_desc);
  665.  
  666. #ifndef GTK_DISABLE_DEPRECATED
  667. #define gtk_widget_set_rc_style(widget)          (gtk_widget_set_style (widget, NULL))
  668. #define gtk_widget_restore_default_style(widget) (gtk_widget_set_style (widget, NULL))
  669. #endif
  670.  
  671. PangoContext *gtk_widget_create_pango_context (GtkWidget   *widget);
  672. PangoContext *gtk_widget_get_pango_context    (GtkWidget   *widget);
  673. PangoLayout  *gtk_widget_create_pango_layout  (GtkWidget   *widget,
  674.                            const gchar *text);
  675.  
  676. GdkPixbuf    *gtk_widget_render_icon          (GtkWidget   *widget,
  677.                                                const gchar *stock_id,
  678.                                                GtkIconSize  size,
  679.                                                const gchar *detail);
  680.  
  681. /* handle composite names for GTK_COMPOSITE_CHILD widgets,
  682.  * the returned name is newly allocated.
  683.  */
  684. void   gtk_widget_set_composite_name    (GtkWidget    *widget,
  685.                      const gchar       *name);
  686. gchar* gtk_widget_get_composite_name    (GtkWidget    *widget);
  687.      
  688. /* Descend recursively and set rc-style on all widgets without user styles */
  689. void       gtk_widget_reset_rc_styles   (GtkWidget      *widget);
  690.  
  691. /* Push/pop pairs, to change default values upon a widget's creation.
  692.  * This will override the values that got set by the
  693.  * gtk_widget_set_default_* () functions.
  694.  */
  695. void         gtk_widget_push_colormap         (GdkColormap *cmap);
  696. void         gtk_widget_push_composite_child (void);
  697. void         gtk_widget_pop_composite_child  (void);
  698. void         gtk_widget_pop_colormap         (void);
  699.  
  700. /* widget style properties
  701.  */
  702. void gtk_widget_class_install_style_property        (GtkWidgetClass     *klass,
  703.                              GParamSpec         *pspec);
  704. void gtk_widget_class_install_style_property_parser (GtkWidgetClass     *klass,
  705.                              GParamSpec         *pspec,
  706.                              GtkRcPropertyParser parser);
  707. GParamSpec*  gtk_widget_class_find_style_property   (GtkWidgetClass     *klass,
  708.                              const gchar        *property_name);
  709. GParamSpec** gtk_widget_class_list_style_properties (GtkWidgetClass     *klass,
  710.                              guint              *n_properties);
  711. void gtk_widget_style_get_property (GtkWidget         *widget,
  712.                     const gchar    *property_name,
  713.                     GValue         *value);
  714. void gtk_widget_style_get_valist   (GtkWidget         *widget,
  715.                     const gchar    *first_property_name,
  716.                     va_list         var_args);
  717. void gtk_widget_style_get          (GtkWidget         *widget,
  718.                     const gchar    *first_property_name,
  719.                     ...) G_GNUC_NULL_TERMINATED;
  720.  
  721.  
  722. /* Set certain default values to be used at widget creation time.
  723.  */
  724. void         gtk_widget_set_default_colormap (GdkColormap *colormap);
  725. GtkStyle*    gtk_widget_get_default_style    (void);
  726. #ifndef GDK_MULTIHEAD_SAFE
  727. GdkColormap* gtk_widget_get_default_colormap (void);
  728. GdkVisual*   gtk_widget_get_default_visual   (void);
  729. #endif
  730.  
  731. /* Functions for setting directionality for widgets
  732.  */
  733.  
  734. void             gtk_widget_set_direction         (GtkWidget        *widget,
  735.                            GtkTextDirection  dir);
  736. GtkTextDirection gtk_widget_get_direction         (GtkWidget        *widget);
  737.  
  738. void             gtk_widget_set_default_direction (GtkTextDirection  dir);
  739. GtkTextDirection gtk_widget_get_default_direction (void);
  740.  
  741. /* Counterpart to gdk_window_shape_combine_mask.
  742.  */
  743. void         gtk_widget_shape_combine_mask (GtkWidget *widget,
  744.                         GdkBitmap *shape_mask,
  745.                         gint       offset_x,
  746.                         gint       offset_y);
  747.  
  748. /* internal function */
  749. void         gtk_widget_reset_shapes       (GtkWidget *widget);
  750.  
  751. /* Compute a widget's path in the form "GtkWindow.MyLabel", and
  752.  * return newly alocated strings.
  753.  */
  754. void         gtk_widget_path           (GtkWidget *widget,
  755.                         guint     *path_length,
  756.                         gchar    **path,
  757.                         gchar    **path_reversed);
  758. void         gtk_widget_class_path       (GtkWidget *widget,
  759.                         guint     *path_length,
  760.                         gchar    **path,
  761.                         gchar    **path_reversed);
  762.  
  763. GList* gtk_widget_list_mnemonic_labels  (GtkWidget *widget);
  764. void   gtk_widget_add_mnemonic_label    (GtkWidget *widget,
  765.                      GtkWidget *label);
  766. void   gtk_widget_remove_mnemonic_label (GtkWidget *widget,
  767.                      GtkWidget *label);
  768.  
  769. GType           gtk_requisition_get_type (void) G_GNUC_CONST;
  770. GtkRequisition *gtk_requisition_copy     (const GtkRequisition *requisition);
  771. void            gtk_requisition_free     (GtkRequisition       *requisition);
  772.  
  773. #if    defined (GTK_TRACE_OBJECTS) && defined (__GNUC__)
  774. #  define gtk_widget_ref gtk_object_ref
  775. #  define gtk_widget_unref gtk_object_unref
  776. #endif    /* GTK_TRACE_OBJECTS && __GNUC__ */
  777.  
  778. void              _gtk_widget_grab_notify                 (GtkWidget    *widget,
  779.                                    gboolean    was_grabbed);
  780.  
  781. GtkWidgetAuxInfo *_gtk_widget_get_aux_info                (GtkWidget    *widget,
  782.                                gboolean      create);
  783. void              _gtk_widget_propagate_hierarchy_changed (GtkWidget    *widget,
  784.                                GtkWidget    *previous_toplevel);
  785. void              _gtk_widget_propagate_screen_changed    (GtkWidget    *widget,
  786.                                GdkScreen    *previous_screen);
  787.  
  788. GdkColormap* _gtk_widget_peek_colormap (void);
  789.  
  790. G_END_DECLS
  791.  
  792. #endif /* __GTK_WIDGET_H__ */
  793.